> ## Documentation Index > Fetch the complete documentation index at: https://mintlify.com/octra-labs/pvac_hfhe_cpp/llms.txt > Use this file to discover all available pages before exploring further. # Types > Core types and structures used in PVAC-HFHE ## Overview This module defines the fundamental types, structures, and enumerations used throughout PVAC-HFHE, including cryptographic keys, ciphertexts, parameters, and graph structures for homomorphic operations. ## Structures ### Params Parameters controlling the security and performance of the PVAC-HFHE scheme. ```cpp theme={null} struct Params { int B = 337; int m_bits = 8192; int n_bits = 16384; int h_col_wt = 192; int x_col_wt = 128; int err_wt = 128; double noise_entropy_bits = 120.0; double tuple2_fraction = 0.55; double depth_slope_bits = 16.0; size_t edge_budget = 1200000; int lpn_n = 4096; int lpn_t = 16384; int lpn_tau_num = 1; int lpn_tau_den = 8; double recrypt_lo = 0.48; double recrypt_hi = 0.52; int recrypt_rounds = 8; }; ``` Multiplicative group carrier for homomorphic properties Dimension parameter m in bits Dimension parameter n in bits Column weight for H matrix Column weight for x matrix Error weight parameter Noise entropy in bits for security Fraction parameter for tuple generation Depth slope parameter in bits Maximum number of edges in computation graph LPN dimension parameter LPN sample count parameter LPN noise rate numerator (τ = lpn\_tau\_num / lpn\_tau\_den) LPN noise rate denominator (τ = 1/8) Lower bound for recryption threshold Upper bound for recryption threshold Number of recryption rounds The default parameters provide: * Information-theoretic security: 2226 bits * Classical security: 200+ bits * Quantum security: 100+ bits ### Fp Field element represented as a 127-bit integer using two 64-bit words. ```cpp theme={null} struct Fp { uint64_t lo; uint64_t hi; }; ``` Low 64 bits of the field element High 63 bits of the field element (top bit unused) Fp represents elements in the field modulo 2^127 - 1 (Mersenne prime p = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF). ### PubKey Public key for encryption and evaluation. ```cpp theme={null} struct PubKey { Params prm; uint64_t canon_tag; std::vector H; Ubk ubk; std::array H_digest; Fp omega_B; std::vector powg_B; }; ``` Scheme parameters Canonical tag for key identification Public matrix H for LPN-based encryption Permutation data for universal broadcast SHA-256 digest of matrix H B-th root of unity in the field Precomputed powers for evaluation ### SecKey Secret key for decryption. ```cpp theme={null} struct SecKey { std::array prf_k; std::vector lpn_s_bits; }; ``` PRF key for pseudorandom generation (256 bits) LPN secret vector in packed bit format ### Cipher Ciphertext structure representing encrypted data and computation graph. ```cpp theme={null} struct Cipher { std::vector L; std::vector E; std::vector c0; size_t slots = 1; }; ``` Computation layers in the DAG Edges connecting layers in the computation graph Base ciphertext vector Number of message slots (for batching) ### Layer Computation layer in the evaluation graph. ```cpp theme={null} struct Layer { RRule rule; RSeed seed; uint32_t pa; uint32_t pb; }; ``` Computation rule type (BASE or PROD) Random seed for deterministic randomness expansion Parent index A Parent index B ### Edge Edge in the computation graph with associated weights. ```cpp theme={null} struct Edge { uint32_t layer_id; uint16_t idx; uint8_t ch; std::vector w; BitVec s; }; ``` Index of the layer this edge connects to Edge index within the layer Sign/channel indicator (SGN\_P or SGN\_M) Weight vector in the field Binary selection vector ### EvalKey Evaluation key for homomorphic operations. ```cpp theme={null} struct EvalKey { std::vector zero_pool; Cipher enc_one; }; ``` Pool of zero encryptions for noise refreshing Encryption of the value 1 ### Nonce128 128-bit nonce for randomization. ```cpp theme={null} struct Nonce128 { uint64_t lo; uint64_t hi; }; ``` Low 64 bits High 64 bits ### RSeed Random seed structure. ```cpp theme={null} struct RSeed { uint64_t ztag; Nonce128 nonce; }; ``` Tag for domain separation 128-bit nonce ### Ubk Permutation data for universal broadcast key. ```cpp theme={null} struct Ubk { std::vector perm; std::vector inv; }; ``` Permutation array Inverse permutation array ## Enumerations ### RRule Computation rule type for layers. ```cpp theme={null} enum class RRule : uint8_t { BASE = 0, PROD = 1 }; ``` Base layer (input) Product layer (multiplication) ### EdgeSign Sign indicator for edges. ```cpp theme={null} enum EdgeSign : uint8_t { SGN_P = 0, SGN_M = 1 }; ``` Positive sign Negative sign (minus) ## Functions ### make\_nonce128 Generates a random 128-bit nonce. ```cpp theme={null} Nonce128 make_nonce128(); ``` Cryptographically secure random nonce ### sgn\_val Converts edge sign to integer value. ```cpp theme={null} int sgn_val(uint8_t ch); ``` Edge sign (SGN\_P or SGN\_M) Returns +1 for SGN\_P, -1 for SGN\_M ### rand\_fp\_nonzero Generates a random non-zero field element. ```cpp theme={null} Fp rand_fp_nonzero(); ``` Random non-zero field element This function loops until a non-zero element is generated. ## Domain Separation Constants The `Dom` namespace provides string constants for domain separation in cryptographic operations: ```cpp theme={null} namespace Dom { inline constexpr const char* H_GEN = "pvac.dom.h_gen"; inline constexpr const char* X_SEED = "pvac.dom.x_seed"; inline constexpr const char* NOISE = "pvac.dom.noise"; inline constexpr const char* PRF_LPN = "pvac.dom.prf_lpn"; inline constexpr const char* TOEP = "pvac.dom.toeplitz"; inline constexpr const char* ZTAG = "pvac.dom.ztag"; inline constexpr const char* COMMIT = "pvac.dom.commit"; inline constexpr const char* PRF_R1 = "pvac.prf.r.1"; inline constexpr const char* PRF_R2 = "pvac.prf.r.2"; inline constexpr const char* PRF_R3 = "pvac.prf.r.3"; inline constexpr const char* PRF_NOISE1 = "pvac.prf.noise.1"; inline constexpr const char* PRF_NOISE2 = "pvac.prf.noise.2"; inline constexpr const char* PRF_NOISE3 = "pvac.prf.noise.3"; } ``` These domain separation constants are critical for security. Never modify them unless you fully understand the cryptographic implications. ## Related * [Field operations](/api/core/field) * [BitVec operations](/api/core/bitvec) * [Random generation](/api/core/random)